package juc.thread;

import java.util.concurrent.*;

/**
 * @auther dyhan
 * @create 2020/3/13
 * 第四种使用java 多线程的方式
 *
 * 手动构建线程池参数含义解析：
 * corePoolSize:核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，
 *              默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，
 *              除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，
 *              是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，
 *              线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
 * maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
 *                  若队列满了之后，线程池则会在corePoolSize 的基础上再次进行创建线程，但是最大不会超过这个参数设置的值
 * keepAliveTime: 表示线程没有任务执行时最多保持多久时间会终止
 *               默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，
 *               即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，
 *               直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，
 *               在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
 * unit：参数keepAliveTime的时间单位
 * workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
 *              ArrayBlockingQueue;
 *              LinkedBlockingQueue;
 *              SynchronousQueue;
 *            ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
 * threadFactory：线程工厂，主要用来创建线程
 * handler：表示当拒绝处理任务时的策略，有以下四种取值：
 *              ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
 *              ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
 *              ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
 *              ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
 *
 *
 *  阿里巴巴开发手册为什么不允许使用Executors来创建线程池？？
 *  FixedThreadPoll 和 SingleThreadPool 允许请求的队列的长度为Integer.MAX_VALUE,可能会堆积大量的请求，从而导致OOM
 *  CachedThreadPool 允许创建的线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM
 *  而且Executors创建的线程池的拒绝策略都为直接拒绝，这很有可能并不符合实际的需求
 *
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor myThreadPool = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        // 线程池拒绝策略
        // AbortPolicy(默认):直接抛出RejectedException异常阻止系统正常运行
        // CallerRunPolicy:"调用者运行"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将线程交给调用线程池的线程运行
        // DiscardOldestPolicy:抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交
        // DiscardPolicy:直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略
        try {
            for (int i = 0; i < 9; i++) {
                myThreadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t开始执行任务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            myThreadPool.shutdown();
        }
        javaDefineThreadPool();
    }

    public static void javaDefineThreadPool(){
        final ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
        final ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        final ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        final ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(3);
        final ExecutorService newWorkStealingPool = Executors.newWorkStealingPool();

        try {
            for (int i = 0; i < 5; i++) {
                newScheduledThreadPool.execute(()-> System.out.println(Thread.currentThread().getName()+"\t线程池开始执行任务"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            newScheduledThreadPool.shutdown();
        }
    }
}
